{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "自定义函数g实现表达式的运算功能和表现能力"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(f, a, b=None):\n",
    "    \"\"\"\n",
    "    f: 一元或二元运算函数\n",
    "    a: 第一个参数\n",
    "    b: 如果f是一元运算函数，则b为空，否则代表二元运算的第二个参数\n",
    "    \"\"\"\n",
    "    if b is None:\n",
    "        return f(a)\n",
    "    else:\n",
    "        return f(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "针对常见的一元运算（对数、平方根、平方、立方、倒数、sigmoid、tanh、relu、binary）、二元运算(加、减、乘、除)可重新定义函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "min_number = 0.01\n",
    "\n",
    "# 一元运算\n",
    "def log(x):\n",
    "    return np.sign(x)*np.log2(np.abs(x)+1)\n",
    "\n",
    "def sqrt(x):\n",
    "    return np.sqrt(x-np.min(x)+min_number)\n",
    "\n",
    "def pow2(x):\n",
    "    return x**2\n",
    "\n",
    "def pow3(x):\n",
    "    return x**3\n",
    "\n",
    "def inv(x):\n",
    "    return 1*np.sign(x)/(np.abs(x)+min_number)\n",
    "\n",
    "def sigmoid(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return (1 + np.exp(-x))**(-1)\n",
    "\n",
    "def tanh(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return (np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x))\n",
    "\n",
    "def relu(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return np.array([e if e > 0 else 0 for e in x])\n",
    "\n",
    "def binary(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return np.array([1 if e > 0 else 0 for e in x])\n",
    "\n",
    "# 二元运算\n",
    "def add(x,y):\n",
    "    return x + y\n",
    "\n",
    "def sub(x,y):\n",
    "    return x - y\n",
    "\n",
    "def times(x,y):\n",
    "    return x * y\n",
    "\n",
    "def div(x,y):\n",
    "    return x*np.sign(y)/(np.abs(y)+min_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "表达式的计算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.219458431129446"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(times,g(add,g(np.sin,5),10),g(log,46))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义函数gen_full_tree_exp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# 定义二元运算函数的集合\n",
    "two_group = ['add', 'sub', 'times', 'div']\n",
    "\n",
    "# 定义一元运算函数的集合\n",
    "one_group = ['log', 'sqrt', 'pow2', 'pow3', 'inv', 'sigmoid', 'tanh', 'relu', 'binary']\n",
    "\n",
    "# 随机增加一元运算符\n",
    "def add_one_group(feature_string, prob=0.3):\n",
    "    return 'g('+random.choice(one_group)+','+feature_string+')' if np.random.uniform(0, 1) < prob else feature_string\n",
    "\n",
    "# 构建满二叉树，并生成数学表达式\n",
    "def gen_full_tree_exp(var_flag_array):\n",
    "    half_n = len(var_flag_array)//2\n",
    "    middle_array = []\n",
    "    for i in range(half_n):\n",
    "        if var_flag_array[i] == '0' and var_flag_array[i+half_n] != '0':\n",
    "            middle_array.append('g('+random.choice(one_group)+','+add_one_group(var_flag_array[i+half_n])+')')\n",
    "        elif var_flag_array[i] != '0' and var_flag_array[i+half_n] == '0':\n",
    "            middle_array.append('g('+random.choice(one_group)+','+add_one_group(var_flag_array[i])+')')\n",
    "        elif var_flag_array[i] != '0' and var_flag_array[i+half_n] != '0':\n",
    "            middle_array.append('g('+random.choice(two_group)+','+add_one_group(var_flag_array[i])+','+add_one_group(var_flag_array[i+half_n])+')')\n",
    "    if len(middle_array) == 1:\n",
    "        return add_one_group(middle_array[0])\n",
    "    else:\n",
    "        return gen_full_tree_exp(middle_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "假设原始属性的下标为1~8，nMax=10，'0'为虚拟特征，则从原始属性中随机选取N个属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0',\n",
       " 'X8',\n",
       " 'X6',\n",
       " '0',\n",
       " 'X8',\n",
       " '0',\n",
       " '0',\n",
       " 'X6',\n",
       " 'X4',\n",
       " 'X1',\n",
       " '0',\n",
       " 'X5',\n",
       " '0',\n",
       " 'X1',\n",
       " 'X4',\n",
       " 'X8']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机抽取 N 个特征下标\n",
    "nMax=10\n",
    "N = random.choice(range(2,nMax+1))\n",
    "\n",
    "# 定义原始数据集中属性的下标1-8\n",
    "featureIdx = range(1,9)\n",
    "select_feature_index = [random.choice(featureIdx) for i in range(N)]+[0]*int(2**np.ceil(np.log2(N)) - N)\n",
    "random.shuffle(select_feature_index)\n",
    "select_feature_index = ['X'+str(e) if e> 0 else '0' for e in select_feature_index]\n",
    "select_feature_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "按满二叉树方式生成特征表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g(tanh,g(times,g(times,g(add,g(sqrt,X4),g(pow3,X8)),g(div,g(inv,g(sqrt,X6)),g(binary,X4))),g(binary,g(add,g(pow2,g(times,g(sqrt,g(sub,X8,X1)),g(pow3,g(pow3,X1)))),g(div,g(inv,X5),g(pow2,g(times,X6,X8)))))))'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree_exp = gen_full_tree_exp(select_feature_index)\n",
    "tree_exp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义函数gen_side_tree_exp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#构建偏二叉树，并生成数学表达式\n",
    "def gen_side_tree_exp(var_flag_array):\n",
    "    if len(var_flag_array) == 1:\n",
    "        return add_one_group(var_flag_array[0])\n",
    "    else:\n",
    "        var_flag_array[1] = 'g('+random.choice(two_group)+','+add_one_group(var_flag_array[0])+','+add_one_group(var_flag_array[1])+')'\n",
    "        del var_flag_array[0]\n",
    "        return gen_side_tree_exp(var_flag_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从原始属性中随机选取N个属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['X6', 'X6', 'X2']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = random.choice(range(2,nMax+1))\n",
    "select_feature_index = ['X'+str(e) for e in [random.choice(featureIdx) for i in range(N)]]\n",
    "select_feature_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "按偏二叉树方式生成特征表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g(div,g(times,g(sqrt,X6),X6),g(log,X2))'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree_exp = gen_side_tree_exp(select_feature_index)\n",
    "tree_exp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "编写Python函数random_get_tree，实现特征表达式的随机生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_get_tree(input_data,featureIdx,nMax=10):\n",
    "    \"\"\" \n",
    "    从原始数据特征中，随机获取特征表达树  \n",
    "    featureIdx: 原始特征的下标数值，最小从1开始\n",
    "    nMax:一次最多从特征中可放回抽样次数，默认为10\n",
    "    \"\"\"\n",
    "    data = pd.DataFrame({\"X\"+str(e):input_data.iloc[:,(e-1)].values for e in featureIdx})\n",
    "    \n",
    "    # 随机抽取N个特征下标\n",
    "    N = random.choice(range(2,nMax+1))\n",
    "    \n",
    "    # 随机决定是使用满二叉树还是偏二叉树\n",
    "    if random.choice([0,1]) == 1:\n",
    "        # 选择满二叉树\n",
    "        select_feature_index = [random.choice(featureIdx) for i in range(N)]+[0]*int(2**np.ceil(np.log2(N)) - N)\n",
    "        random.shuffle(select_feature_index)\n",
    "        select_feature_index = ['data.X'+str(e)+\".values\" if e> 0 else '0' for e in select_feature_index]\n",
    "        tree_exp = gen_full_tree_exp(select_feature_index)\n",
    "    else:\n",
    "        # 选择偏二叉树\n",
    "        select_feature_index = ['data.X'+str(e)+\".values\" for e in [random.choice(featureIdx) for i in range(N)]]\n",
    "        tree_exp =  gen_side_tree_exp(select_feature_index)\n",
    "    return {\"f_value\":eval(tree_exp),\"tree_exp\":tree_exp.replace(\"data.\",\"\").replace(\".values\",\"\")}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以iris数据集为例，其特征下标为1:4，则使用random_get_tree函数随机生成一个特征表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g(log,g(sub,g(div,X1,g(relu,X2)),g(sub,g(tanh,X2),g(relu,X3))))'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "iris = pd.read_csv(\"http://image.cador.cn/data/iris.csv\")\n",
    "out = random_get_tree(iris,[1,2,3,4])\n",
    "out['tree_exp']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.37484101, 0.1778776 , 3.86504948, 5.43992791, 2.04359372,\n",
       "       1.49057503, 2.60901032, 2.72281499, 0.42988853, 5.52923905,\n",
       "       1.89695809, 2.66703453, 0.1778776 , 0.1778776 , 1.42562205,\n",
       "       0.88156743, 1.49057503, 2.37484101, 1.75622778, 1.59894514,\n",
       "       2.82829504, 1.81674199, 1.92791555, 3.24218814, 2.66703453,\n",
       "       0.1778776 , 2.72281499, 2.4016217 , 2.7765188 , 3.86504948,\n",
       "       5.5000787 , 2.82829504, 1.12023908, 1.06582127, 5.52923905,\n",
       "       3.95025425, 2.47910425, 2.01553206, 0.1778776 , 2.74991677,\n",
       "       2.34755376, 0.95651372, 3.77449497, 2.34755376, 1.59894514,\n",
       "       0.1778776 , 1.59894514, 3.83549172, 1.87071186, 3.2151217 ,\n",
       "       4.4530588 , 4.32310939, 6.02927151, 1.05530763, 1.00731844,\n",
       "       0.96593856, 3.59790023, 0.93168172, 0.86845021, 0.81325811,\n",
       "       0.98894877, 0.46721677, 1.07015385, 0.91267903, 0.42988853,\n",
       "       5.98138388, 0.63501342, 0.90369399, 1.25329007, 0.95455486,\n",
       "       4.22569256, 0.73911078, 1.32559126, 1.04754447, 0.72699539,\n",
       "       0.58122085, 1.08667926, 0.87746104, 0.82282247, 0.83420929,\n",
       "       0.94962454, 0.93168172, 0.81325811, 1.28642249, 0.63501342,\n",
       "       3.04879353, 5.98527226, 1.20508655, 0.40664821, 0.99625786,\n",
       "       1.10284346, 0.68687216, 0.94142651, 0.95651372, 0.94687124,\n",
       "       0.46721677, 0.67658418, 0.72699539, 0.89318546, 0.78741922,\n",
       "       3.68335775, 1.28642249, 1.23184781, 1.25946828, 1.19650554,\n",
       "       1.45761433, 1.18840482, 1.48126633, 1.59354151, 2.84819409,\n",
       "       4.36827271, 1.3521366 , 1.08496666, 1.35794227, 1.19809079,\n",
       "       4.35551547, 1.08496666, 2.63537336, 1.8354033 , 1.41577572,\n",
       "       4.47092153, 1.12478044, 1.67976484, 1.21757168, 3.74199975,\n",
       "       4.53809811, 1.08667926, 0.83212191, 1.36655754, 1.19650554,\n",
       "       1.51739297, 2.62273196, 1.36655754, 1.19809079, 1.50071284,\n",
       "       1.30003644, 3.2134978 , 5.93150529, 0.78531156, 6.0355354 ,\n",
       "       5.99687492, 6.03178033, 1.28642249, 4.45904406, 3.74199975,\n",
       "       0.96407636, 1.35794227, 0.96407636, 3.17586089, 0.92141862])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out['f_value']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义二叉树节点类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self, value, label, left=None, right=None):\n",
    "        self.value = value\n",
    "        self.label = label\n",
    "        self.left = left  \n",
    "        self.right = right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义transform函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'g(sqrt,X1)',\n",
       " 1: 'g(sub,<0>,X1)',\n",
       " 2: 'g(binary,X2)',\n",
       " 3: 'g(times,<2>,X3)',\n",
       " 4: 'g(div,<1>,<3>)',\n",
       " 5: 'g(sigmoid,X3)',\n",
       " 6: 'g(add,X4,X2)',\n",
       " 7: 'g(div,<5>,<6>)',\n",
       " 8: 'g(add,<4>,<7>)'}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def transform(feature_string):\n",
    "    my_dict={}\n",
    "    pattern = r'g\\([^\\(\\)]*\\)'\n",
    "    so = re.search(pattern, feature_string)\n",
    "    while so:\n",
    "        start, end = so.span()\n",
    "        key = len(my_dict)\n",
    "        my_dict[key]=so.group()\n",
    "        feature_string = feature_string[0:start]+'<'+str(key)+'>'+feature_string[end:]\n",
    "        so = re.search(pattern, feature_string)\n",
    "    return my_dict\n",
    "\n",
    "exp_tmp = 'g(add,g(div,g(sub,g(sqrt,X1),X1),g(times,g(binary,X2),X3)),g(div,g(sigmoid,X3),g(add,X4,X2)))'\n",
    "transform(exp_tmp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义parse函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse(group_unit):\n",
    "    tmp = group_unit.lstrip(\"g(\").rstrip(\")\").split(',')\n",
    "    tmp = tmp + [None] if len(tmp) == 2 else tmp\n",
    "    return [int(x[1:-1]) if x is not None and re.match(r'<[0-9]+>',x) else x for x in tmp]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "编写bitree函数，通过深度优化遍历的方式构建二叉树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bitree(mapping, start_no, index=0, labels={}):\n",
    "    name, left, right = parse(mapping[start_no])\n",
    "    if left is not None:\n",
    "        if type(left) == int:\n",
    "            left_node, s_labels, max_index = bitree(mapping, left, index+1, labels)\n",
    "            labels = s_labels\n",
    "        else:\n",
    "            left_node = Node(index+1, left)\n",
    "            labels[index+1] = left\n",
    "            max_index = index+1\n",
    "    else:\n",
    "        left_node = None\n",
    "    \n",
    "    if right is not None:\n",
    "        if type(right) == int:\n",
    "            right_node, s_labels, max_index = bitree(mapping, right, max_index+1, labels)\n",
    "            labels = s_labels\n",
    "        else:\n",
    "            right_node = Node(max_index+1, right)\n",
    "            labels[max_index+1] = right\n",
    "            max_index = max_index+1\n",
    "    else:\n",
    "        right_node = None\n",
    "        \n",
    "    labels[index] = name\n",
    "    return Node(index, name, left_node, right_node) ,labels, max_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义create_graph函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_graph(G, node, pos={}, x=0, y=0, layer=1):\n",
    "    pos[node.value] = (x, y)\n",
    "    if node.left:\n",
    "        G.add_edge(node.value, node.left.value)\n",
    "        l_x, l_y = x - 1 / layer, y - 1\n",
    "        l_layer = layer + 1\n",
    "        create_graph(G, node.left, x=l_x, y=l_y, pos=pos, layer=l_layer)\n",
    "    if node.right:\n",
    "        G.add_edge(node.value, node.right.value)\n",
    "        r_x, r_y = x + 1 / layer, y - 1\n",
    "        r_layer = layer + 1\n",
    "        create_graph(G, node.right, x=r_x, y=r_y, pos=pos, layer=r_layer)\n",
    "    return G, pos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "编写Python代码，对特征表达式字符串exp_tmp，绘制对应的二叉树图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x792 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "# 以下 font.family 设置仅适用于 Mac系统，其它系统请使用对应字体名称\n",
    "matplotlib.rcParams['font.family'] = 'Arial Unicode MS'\n",
    "\n",
    "def plot_tree(feature_string, title=None, node_size=3000, font_size=18):\n",
    "    my_dict = transform(feature_string)\n",
    "    root, labels, _ = bitree(my_dict, len(my_dict)-1, 0, labels={})\n",
    "    graph = nx.Graph()\n",
    "    graph, pos = create_graph(graph, root)\n",
    "    nx.draw_networkx(graph, pos, node_size=node_size,width=2,node_color='black',font_color='white',font_size=font_size,with_labels=True,labels=labels)\n",
    "    plt.axis('off')\n",
    "    if title is not None:\n",
    "        plt.title(title)\n",
    "    \n",
    "plt.figure(figsize=(20,11))\n",
    "plot_tree(exp_tmp)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
